#include <iostream>

using namespace std;

#include "tporo.h"
#include "tlistaporo.h"
#include "tcolaabbporo.h"
#include "tabbporo.h"

TColaABBPoro::TColaABBPoro()
{
	primero = NULL;
	ultimo = NULL;
}
TColaABBPoro::TColaABBPoro(const TColaABBPoro & cola)
{
	primero = NULL;
	ultimo = NULL;
	if(cola.EsVacia() == false)
	{
		TECAP *p = cola.primero;
		for(int i = 0; i <= cola.Longitud(); i++)
		{
			Encolar(p->arbol);
			if(p->sig != NULL)
			{
				p = p->sig;
			}
		}
	}
}
TColaABBPoro::~TColaABBPoro()
{
	if(primero != NULL)
	{
		TECAP *p, *q;

		p = primero;
		while(p != NULL)
		{
			q = p;
			p = p->sig;
			delete q;
		}
	}

	primero = NULL;
	ultimo = NULL;
}
TColaABBPoro & TColaABBPoro::operator=(const TColaABBPoro & cola)
{
	if(EsVacia() == false)
	{
		(*this).~TColaABBPoro();
	}
	if(cola.EsVacia() != true)
	{
		TECAP *p = cola.primero;
		for(int i = 0; i < cola.Longitud(); i++)
		{
			(*this).Encolar(p->arbol);
			if(p->sig != NULL)
			{
				p = p->sig;
			}
		}
	}
		
	return (*this);
}
bool TColaABBPoro::operator==(const TColaABBPoro & cola)
{
	bool iguales = true;
	
	if(!EsVacia() && !cola.EsVacia())
	{
		TECAP *p = primero;
		TECAP *q = cola.primero;

		if(Longitud() != cola.Longitud())
		{
			iguales = false;
		}else
		{
			while( p != NULL && q != NULL && iguales == true)
			{
				if(p->arbol != q->arbol)
				{
					iguales = false;
				}
				if(p->sig != NULL)
				{
					p = p->sig;
				}
				if(q->sig != NULL)
				{
					q = q->sig;
				}
			}
		}
	}
			
	return iguales;
}
TColaABBPoro TColaABBPoro::operator+(const TColaABBPoro & cola)
{
	//Hacerlo nuevo entero
	TColaABBPoro nueva;
	if(this->EsVacia() != true)
	{
		nueva = *this;
	}
	
	bool NoR = true;
	TECAP *p;
	
	if(cola.EsVacia() != true)
	{
		p = cola.primero;
	}
	
	while(p != NULL)
	{
		nueva.Encolar(p->arbol);
		if(p->sig != NULL)
		{
			p = p->sig;
		}else
		{
			p = NULL;
		}
	}
	
	return nueva;
}
bool TColaABBPoro::EsVacia() const
{
	bool vacio = false;
	
	if(primero == NULL)
	{
		vacio = true;
	}
	
	return vacio;
}
bool TColaABBPoro::Encolar(TABBPoro * a)
{
	bool encolar = false;

	if(a != NULL)
	{
		TECAP *q;
		bool encontrado = false;
		
		if(primero != NULL)
			q = primero;
		else
			q = NULL;
		
		while(q != NULL)
		{
			if(q->arbol->Raiz().Volumen() == a->Raiz().Volumen())
			{
				encontrado = true;
			}
			q = q->sig;
		}
		if(encontrado == false)
		{
			TECAP *p;
			p = new TECAP();
			p->arbol = a;
				
			if(EsVacia()==true)
			{
				primero = p;
				ultimo = p; 
				encolar = true;
			}else
			{
				
				ultimo->sig = p;
				ultimo = p;
				encolar = true;
			}
		}
	}else
	{
		TECAP *p;
	    p = new TECAP();
	    ultimo->sig = p;
	    ultimo = p;
	}
		
	return encolar;
}
bool TColaABBPoro::Desencolar()
{
	bool desencolar = true;
	TECAP *p = primero;
	if(primero == NULL)
	{
		desencolar = false;
	}else
	{
		if(primero->sig != NULL)
		{
			primero = p->sig;
		}else
		{
			ultimo = NULL;
			primero = NULL;
		}
		delete p;
		
	}
	
	return desencolar;
}
TABBPoro * TColaABBPoro::Cabeza()
{
	if(EsVacia())
		return(NULL);
	else
		return(primero->arbol);
}
int TColaABBPoro::Longitud() const
{
	int lon = 0;
	TECAP *p = primero; 
	
	while(p != NULL)
	{
		lon++;
		p = p->sig;
	}
	
	return lon;
}
ostream & operator<<(ostream & os,const TColaABBPoro & cola)
{

	os<<"(";
	if(cola.EsVacia() == false)
	{
		TECAP * p; 
		TABBPoro *a;
		TPoro item;
		p = cola.primero;
		int i = 0;
		while(p != NULL)
		{
			a = p->Arbol();
			if( a == NULL)
			{
				os<<".";
			}else
			{
				item = a->Raiz();
				os<<item;
			}
			if(p->Siguiente() != NULL)
				os<<" ";
			p = p->Siguiente();
			i++;
		}
			
	}
	os<<")";
	
	return os;
}

//---------------------->TECAP<-----------------------------------------------------

TECAP::TECAP()
{
	arbol = NULL;
	sig = NULL;
}
TECAP::TECAP(const TECAP & cap)
{
	arbol = cap.arbol;
	sig = cap.sig;
}
TECAP::~TECAP()
{
	if( arbol != NULL )
	{
		//arbol->~TABBPoro();
		arbol = NULL;
	}
	sig = NULL;
}
TECAP & TECAP::operator=( const TECAP & cap)
{
	if((*this) != cap)
	{
		arbol = cap.arbol;
		sig = cap.sig;
	}
	
	return (*this);
}

bool TECAP::operator==(const TECAP & cap) const
{
	bool iguales = true;
	
	if(arbol != cap.arbol)
	{
		iguales = false;
	}
	
	return iguales;
}
bool TECAP::operator!=(const TECAP & cap) const
{
	bool distintos = true;
	
	if( (*this) == cap )
	{
		distintos = false;
	}
	
	return distintos;
}
TECAP* TECAP::Siguiente()
{
	return(this->sig);
}
TABBPoro* TECAP::Arbol()
{
	return(this->arbol);
}














